{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "79d9aaef",
   "metadata": {},
   "source": [
    "# Market Making with Alpha - APT\n",
    "\n",
    "## Overview\n",
    "\n",
    "Continuing from [Market Making with Alpha - Basis](https://hftbacktest.readthedocs.io/en/latest/tutorials/Market%20Making%20with%20Alpha%20-%20Basis.html), this example demonstrates market making based on [Arbitrage Pricing Theory](https://en.wikipedia.org/wiki/Arbitrage_pricing_theory).\n",
    "\n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">\n",
    "    \n",
    "**Note:** This example is for educational purposes only and demonstrates effective strategies for high-frequency market-making schemes. All backtests are based on a 0.005% rebate, the highest market maker rebate available on Binance Futures. See <a href=\"https://www.binance.com/en/support/announcement/binance-updates-usd%E2%93%A2-margined-futures-liquidity-provider-program-2024-06-03-fefc6aa25e0947e2bf745c1c56bea13e\">Binance Upgrades USDⓢ-Margined Futures Liquidity Provider Program</a> for more details.\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e8d55680",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "from numba import njit, uint64\n",
    "from numba.typed import Dict\n",
    "\n",
    "from hftbacktest import (\n",
    "    BacktestAsset,\n",
    "    ROIVectorMarketDepthBacktest,\n",
    "    GTX,\n",
    "    LIMIT,\n",
    "    BUY,\n",
    "    SELL,\n",
    "    BUY_EVENT,\n",
    "    SELL_EVENT,\n",
    "    Recorder\n",
    ")\n",
    "from hftbacktest.stats import LinearAssetRecord\n",
    "\n",
    "import polars as pl\n",
    "import statsmodels.api as sm\n",
    "from matplotlib import pyplot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ef2e9204-2d4a-434f-acff-70b67f883f37",
   "metadata": {},
   "outputs": [],
   "source": [
    "start_date = datetime.datetime.strptime('20240901', '%Y%m%d')\n",
    "end_date = datetime.datetime.strptime('20241031', '%Y%m%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3d35a651-f930-4d6e-b158-9d6d5a48fa6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_bookticker(file):\n",
    "    return pl.read_csv(file, schema={\n",
    "        'exchange': pl.String,\n",
    "        'symbol': pl.String,\n",
    "        'timestamp': pl.Int64,\n",
    "        'local_timestamp': pl.Int64,\n",
    "        'ask_amount': pl.Float64,\n",
    "        'ask_price': pl.Float64,\n",
    "        'bid_price': pl.Float64,\n",
    "        'bid_amount': pl.Float64\n",
    "    }).with_columns(\n",
    "        pl.col('local_timestamp').cast(pl.Datetime),\n",
    "        mid_price = (.5 * (pl.col('bid_price') + pl.col('ask_price'))),\n",
    "    ).select(['local_timestamp', 'mid_price'])\n",
    "\n",
    "def prepare_px_return(spot_file, futures_file, sampling_interval, rolling_window, shift):\n",
    "    spot = load_bookticker(spot_file)\n",
    "    futures = load_bookticker(futures_file)\n",
    "\n",
    "    # Resamples prices to calculate returns.\n",
    "    spot_rs = spot.group_by_dynamic(\n",
    "        index_column='local_timestamp',\n",
    "        every=sampling_interval\n",
    "    ).agg(\n",
    "        pl.col('mid_price').last()\n",
    "    ).upsample(\n",
    "        time_column='local_timestamp',\n",
    "        every=sampling_interval\n",
    "    ).select(pl.all().forward_fill())\n",
    "    \n",
    "    futures_rs = futures.group_by_dynamic(\n",
    "        index_column='local_timestamp',\n",
    "        every=sampling_interval\n",
    "    ).agg(\n",
    "        pl.col('mid_price').last(),\n",
    "    ).upsample(\n",
    "        time_column='local_timestamp',\n",
    "        every=sampling_interval\n",
    "    ).select(pl.all().forward_fill())\n",
    "\n",
    "    # When computing returns, if one chooses the past price at a specific time point, \n",
    "    # it may result in selecting an noiser value, leading to a noisier return calculation.\n",
    "    # \n",
    "    # To mitigate this issue, the average price over a past period is used. \n",
    "    # For example, to compute 5-minute returns, the average price over a 5-minute window centered around 5 minutes ago is used.\n",
    "    \n",
    "    return spot_rs.join(\n",
    "        futures_rs,\n",
    "        left_on='local_timestamp',\n",
    "        right_on='local_timestamp',\n",
    "        how='full'\n",
    "    ).with_columns(\n",
    "        futures_px=pl.col('mid_price_right').forward_fill(),\n",
    "        spot_px=pl.col('mid_price').forward_fill()\n",
    "    ).with_columns(\n",
    "        futures_past_px=pl.col('futures_px').rolling_mean(window_size=rolling_window).shift(shift),\n",
    "        spot_past_px=pl.col('spot_px').rolling_mean(window_size=rolling_window).shift(shift)\n",
    "    ).with_columns(\n",
    "        local_timestamp=pl.col('local_timestamp').dt.timestamp('ns'),\n",
    "        spot_return=pl.col('spot_px') / pl.col('spot_past_px') - 1,\n",
    "        futures_return=pl.col('futures_px') / pl.col('futures_past_px') - 1,\n",
    "    ).select(\n",
    "        ['local_timestamp', 'spot_return', 'spot_past_px', 'futures_return', 'futures_past_px']\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0b7d1429-e528-4312-a00a-733ce2603fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "date = start_date\n",
    "while date <= end_date:\n",
    "    data.append(prepare_px_return(\n",
    "        f'spot/book_ticker/BTCUSDT/BTCUSDT_{date.strftime(\"%Y%m%d\")}.csv.gz',\n",
    "        f'usdm/book_ticker/BTCUSDT/BTCUSDT_{date.strftime(\"%Y%m%d\")}.csv.gz',\n",
    "        '100ms',\n",
    "        3000, # 5-minute\n",
    "        1500 # 2.5-minute, the average price over a 5-minute window centered around 5 minutes ago\n",
    "    ).to_numpy())\n",
    "    date += datetime.timedelta(days=1)\n",
    "precompute_data = np.concatenate(data, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e608903e-ecc5-4bf9-baf9-db9a12313313",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez_compressed(\"precompute_px_return_BTCUSDT_5m\", data=precompute_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e2b6a2da-0222-4267-9adf-23ad33e7a3cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "precompute_data = np.load(\"precompute_px_return_BTCUSDT_5m.npz\")[\"data\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "384d90e8-e12b-4e39-84a9-060059ed1f5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "spot_returns = precompute_data[:, 1]\n",
    "futures_returns = precompute_data[:, 3]\n",
    "m = np.isfinite(spot_returns) & np.isfinite(futures_returns)\n",
    "\n",
    "spot_returns = spot_returns[m]\n",
    "futures_returns = futures_returns[m]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8a6beb7c-8002-4a52-a2d5-c803d0be225a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pyplot.scatter(spot_returns, futures_returns)\n",
    "pyplot.xlabel('Spot Returns')\n",
    "pyplot.ylabel('Futures Returns')\n",
    "pyplot.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ac30ffed-2d22-4fcb-9484-23036141f15e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   R-squared:                       0.996\n",
      "Model:                            OLS   Adj. R-squared:                  0.996\n",
      "Method:                 Least Squares   F-statistic:                 1.454e+10\n",
      "Date:                Wed, 19 Feb 2025   Prob (F-statistic):               0.00\n",
      "Time:                        07:04:09   Log-Likelihood:             4.2591e+08\n",
      "No. Observations:            52429249   AIC:                        -8.518e+08\n",
      "Df Residuals:                52429247   BIC:                        -8.518e+08\n",
      "Df Model:                           1                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const       1.972e-08   9.91e-09      1.990      0.047    2.96e-10    3.91e-08\n",
      "x1             1.0005    8.3e-06   1.21e+05      0.000       1.000       1.001\n",
      "==============================================================================\n",
      "Omnibus:                 14057736.201   Durbin-Watson:                   0.043\n",
      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):       1426043863.056\n",
      "Skew:                           0.090   Prob(JB):                         0.00\n",
      "Kurtosis:                      28.549   Cond. No.                         837.\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
     ]
    }
   ],
   "source": [
    "X = sm.add_constant(spot_returns)\n",
    "\n",
    "model = sm.OLS(futures_returns, X).fit()\n",
    "\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90633e36-3712-4205-8cea-07f4b0d77b14",
   "metadata": {},
   "source": [
    "Under Arbitrage Pricing Theory, the relationship between futures return and spot return can be expressed as:\n",
    "\n",
    "$Return_{futures} = \\alpha + \\beta_{spot} * Return_{spot}$\n",
    "\n",
    "Under the assumption that $\\beta_{spot}$ = 1 and $\\alpha$ = 0, the futures return should be equal to the spot return. This also implies that any residual movement is mean-reverting to zero, similar to what is shown in the basis example.\n",
    "\n",
    "**Extending the Model**\n",
    "\n",
    "Beyond this basic relationship, additional return-contributing factors can be incorporated. For instance, returns from other exchanges’ Bitcoin markets, such as:\n",
    "\n",
    "* CME Bitcoin futures, Bybit's BTC futures and other platforms's BTC futures\n",
    "* Bitcoin ETFs\n",
    "* Spot prices from Coinbase, Kraken, and other platforms\n",
    "\n",
    "Moreover, this is not limited to the same asset. Other cryptocurrencies, traditional assets, and macroeconomic indices can be considered, such as:\n",
    "\n",
    "* Ethereum (ETH)\n",
    "* S&P 500\n",
    "* Dollar Index\n",
    "\n",
    "Additionally, market microstructure factors, such as order book imbalance, can further enhance the model, as demonstrated in [our other example](https://hftbacktest.readthedocs.io/en/latest/tutorials/Market%20Making%20with%20Alpha%20-%20Order%20Book%20Imbalance.html).\n",
    "\n",
    "This broader framework allows for a more comprehensive understanding of price movements and their underlying drivers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9235306a-32c4-4854-a411-1b1d99af8db7",
   "metadata": {},
   "outputs": [],
   "source": [
    "@njit\n",
    "def apt_mm(\n",
    "    hbt,\n",
    "    stat,\n",
    "    half_spread,\n",
    "    skew,\n",
    "    precompute_data,\n",
    "    interval,\n",
    "    order_qty_dollar,\n",
    "    max_position_dollar,\n",
    "    grid_num,\n",
    "    grid_interval,\n",
    "    roi_lb,\n",
    "    roi_ub\n",
    "):\n",
    "    asset_no = 0\n",
    "\n",
    "    tick_size = hbt.depth(0).tick_size\n",
    "    lot_size = hbt.depth(0).lot_size\n",
    "    \n",
    "    roi_lb_tick = int(round(roi_lb / tick_size))\n",
    "    roi_ub_tick = int(round(roi_ub / tick_size))\n",
    "\n",
    "    data_i = 0\n",
    "    spot_return = np.nan\n",
    "    futures_past_px = np.nan\n",
    "    \n",
    "    while hbt.elapse(interval) == 0:\n",
    "        hbt.clear_inactive_orders(asset_no)\n",
    "        \n",
    "        depth = hbt.depth(asset_no)\n",
    "        position = hbt.position(asset_no)\n",
    "        orders = hbt.orders(asset_no)\n",
    "\n",
    "        best_bid = depth.best_bid\n",
    "        best_ask = depth.best_ask\n",
    "        \n",
    "        while data_i < len(precompute_data):\n",
    "            if precompute_data[data_i, 0] > hbt.current_timestamp:\n",
    "                if data_i > 0:\n",
    "                    spot_return = precompute_data[data_i - 1, 1]\n",
    "                    futures_past_px = precompute_data[data_i - 1, 4]\n",
    "                break\n",
    "            data_i += 1\n",
    "\n",
    "        #--------------------------------------------------------\n",
    "        # Computes bid price and ask price.\n",
    "\n",
    "        mid_price = (best_bid + best_ask) / 2.0\n",
    "        order_qty = max(round((order_qty_dollar / mid_price) / lot_size) * lot_size, lot_size)\n",
    "        \n",
    "        normalized_position = position / order_qty\n",
    "\n",
    "        relative_bid_depth = half_spread + skew * normalized_position\n",
    "        relative_ask_depth = half_spread - skew * normalized_position\n",
    "        beta = 1\n",
    "        alpha = 0\n",
    "        return_ = beta * spot_return + alpha\n",
    "        fair_px = (1 + return_) * futures_past_px\n",
    "\n",
    "        bid_price = min(fair_px * (1.0 - relative_bid_depth), best_bid)\n",
    "        ask_price = max(fair_px * (1.0 + relative_ask_depth), best_ask)\n",
    "        \n",
    "        bid_price = np.floor(bid_price / tick_size) * tick_size\n",
    "        ask_price = np.ceil(ask_price / tick_size) * tick_size\n",
    "        \n",
    "        #--------------------------------------------------------\n",
    "        # Updates quotes.\n",
    "        \n",
    "        # Creates a new grid for buy orders.\n",
    "        new_bid_orders = Dict.empty(np.uint64, np.float64)\n",
    "        if position * mid_price < max_position_dollar and np.isfinite(bid_price):\n",
    "            for i in range(grid_num):\n",
    "                bid_price_tick = round(bid_price / tick_size)\n",
    "                \n",
    "                # order price in tick is used as order id.\n",
    "                new_bid_orders[uint64(bid_price_tick)] = bid_price\n",
    "                \n",
    "                bid_price -= grid_interval\n",
    "\n",
    "        # Creates a new grid for sell orders.\n",
    "        new_ask_orders = Dict.empty(np.uint64, np.float64)\n",
    "        if position * mid_price > -max_position_dollar and np.isfinite(ask_price):\n",
    "            for i in range(grid_num):\n",
    "                ask_price_tick = round(ask_price / tick_size)\n",
    "                \n",
    "                # order price in tick is used as order id.\n",
    "                new_ask_orders[uint64(ask_price_tick)] = ask_price\n",
    "\n",
    "                ask_price += grid_interval\n",
    "                \n",
    "        order_values = orders.values();\n",
    "        while order_values.has_next():\n",
    "            order = order_values.get()\n",
    "            # Cancels if a working order is not in the new grid.\n",
    "            if order.cancellable:\n",
    "                if (\n",
    "                    (order.side == BUY and order.order_id not in new_bid_orders)\n",
    "                    or (order.side == SELL and order.order_id not in new_ask_orders)\n",
    "                ):\n",
    "                    hbt.cancel(asset_no, order.order_id, False)\n",
    "                    \n",
    "        for order_id, order_price in new_bid_orders.items():\n",
    "            # Posts a new buy order if there is no working order at the price on the new grid.\n",
    "            if order_id not in orders:\n",
    "                hbt.submit_buy_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
    "                \n",
    "        for order_id, order_price in new_ask_orders.items():\n",
    "            # Posts a new sell order if there is no working order at the price on the new grid.\n",
    "            if order_id not in orders:\n",
    "                hbt.submit_sell_order(asset_no, order_id, order_price, order_qty, GTX, LIMIT, False)\n",
    "        \n",
    "        # Records the current state for stat calculation.\n",
    "        stat.record(hbt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "99a684f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1h 2min 30s, sys: 1min 50s, total: 1h 4min 20s\n",
      "Wall time: 40min 16s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "roi_lb = 10000\n",
    "roi_ub = 90000\n",
    "\n",
    "data = []\n",
    "date = start_date\n",
    "while date <= end_date:\n",
    "    data.append('data2/btcusdt_{}.npz'.format(date.strftime(\"%Y%m%d\")))\n",
    "    date += datetime.timedelta(days=1)\n",
    "\n",
    "asset = (\n",
    "    BacktestAsset()\n",
    "        .data(data)\n",
    "        .initial_snapshot('data2/btcusdt_20240831_eod.npz')\n",
    "        .linear_asset(1.0) \n",
    "        .constant_latency(10_000_000, 10_000_000)\n",
    "        .power_prob_queue_model(3)\n",
    "        .no_partial_fill_exchange()\n",
    "        .trading_value_fee_model(-0.00005, 0.0007)\n",
    "        .tick_size(0.1)\n",
    "        .lot_size(0.001)\n",
    "        .roi_lb(roi_lb)    \n",
    "        .roi_ub(roi_ub)\n",
    ")\n",
    "\n",
    "hbt = ROIVectorMarketDepthBacktest([asset])\n",
    "\n",
    "recorder = Recorder(1, 60_000_000)\n",
    "\n",
    "half_spread = 0.0003 # a ratio relative to the fair price\n",
    "skew = half_spread / 20\n",
    "interval = 100_000_000 # in nanoseconds. 100ms\n",
    "order_qty_dollar = 50_000\n",
    "max_position_dollar = order_qty_dollar * 20\n",
    "grid_num = 1\n",
    "grid_interval = hbt.depth(0).tick_size\n",
    "\n",
    "apt_mm(\n",
    "    hbt,\n",
    "    recorder.recorder,\n",
    "    half_spread,\n",
    "    skew,\n",
    "    precompute_data,\n",
    "    interval,\n",
    "    order_qty_dollar,\n",
    "    max_position_dollar,\n",
    "    grid_num,\n",
    "    grid_interval,\n",
    "    roi_lb,\n",
    "    roi_ub\n",
    ")\n",
    "\n",
    "hbt.close()\n",
    "\n",
    "recorder.to_npz('stats/underlying_btcusdt_return_5m.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "bc32dd54-0ba7-4db5-a951-3f7ec6b11788",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><style>\n",
       ".dataframe > thead > tr,\n",
       ".dataframe > tbody > tr {\n",
       "  text-align: right;\n",
       "  white-space: pre-wrap;\n",
       "}\n",
       "</style>\n",
       "<small>shape: (1, 11)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>start</th><th>end</th><th>SR</th><th>Sortino</th><th>Return</th><th>MaxDrawdown</th><th>DailyNumberOfTrades</th><th>DailyTurnover</th><th>ReturnOverMDD</th><th>ReturnOverTrade</th><th>MaxPositionValue</th></tr><tr><td>datetime[μs]</td><td>datetime[μs]</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>2024-09-01&nbsp;00:00:00</td><td>2024-10-31&nbsp;23:55:00</td><td>6.801096</td><td>9.590116</td><td>0.047411</td><td>0.008856</td><td>518.324586</td><td>10.366475</td><td>5.35366</td><td>0.000075</td><td>1.0443e6</td></tr></tbody></table></div>"
      ],
      "text/plain": [
       "shape: (1, 11)\n",
       "┌────────────┬───────────┬──────────┬──────────┬───┬───────────┬───────────┬───────────┬───────────┐\n",
       "│ start      ┆ end       ┆ SR       ┆ Sortino  ┆ … ┆ DailyTurn ┆ ReturnOve ┆ ReturnOve ┆ MaxPositi │\n",
       "│ ---        ┆ ---       ┆ ---      ┆ ---      ┆   ┆ over      ┆ rMDD      ┆ rTrade    ┆ onValue   │\n",
       "│ datetime[μ ┆ datetime[ ┆ f64      ┆ f64      ┆   ┆ ---       ┆ ---       ┆ ---       ┆ ---       │\n",
       "│ s]         ┆ μs]       ┆          ┆          ┆   ┆ f64       ┆ f64       ┆ f64       ┆ f64       │\n",
       "╞════════════╪═══════════╪══════════╪══════════╪═══╪═══════════╪═══════════╪═══════════╪═══════════╡\n",
       "│ 2024-09-01 ┆ 2024-10-3 ┆ 6.801096 ┆ 9.590116 ┆ … ┆ 10.366475 ┆ 5.35366   ┆ 0.000075  ┆ 1.0443e6  │\n",
       "│ 00:00:00   ┆ 1         ┆          ┆          ┆   ┆           ┆           ┆           ┆           │\n",
       "│            ┆ 23:55:00  ┆          ┆          ┆   ┆           ┆           ┆           ┆           │\n",
       "└────────────┴───────────┴──────────┴──────────┴───┴───────────┴───────────┴───────────┴───────────┘"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.load('stats/underlying_btcusdt_return_5m.npz')['0']\n",
    "stats = (\n",
    "    LinearAssetRecord(data)\n",
    "        .resample('5m')\n",
    "        .stats(book_size=2_500_000)\n",
    ")\n",
    "stats.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "958c324b-61ba-47f8-bac7-ff9c086e2f72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stats.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11e077ad-2503-43ae-bdda-5aac8580b66b",
   "metadata": {},
   "source": [
    "As demonstrated in the basis example, BTCFDUSD behaves in a similar manner."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1d00dbd5-bced-4e5d-9169-b7fb29e79e20",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "date = start_date\n",
    "while date <= end_date:\n",
    "    data.append(prepare_px_return(\n",
    "        f'spot/book_ticker/BTCFDUSD/BTCFDUSD_{date.strftime(\"%Y%m%d\")}.csv.gz',\n",
    "        f'usdm/book_ticker/BTCUSDT/BTCUSDT_{date.strftime(\"%Y%m%d\")}.csv.gz',\n",
    "        '100ms',\n",
    "        3000, # 5-minute window\n",
    "        1500 # 2.5-minute, the average price over a 5-minute window centered around 5 minutes ago\n",
    "    ).to_numpy())\n",
    "    date += datetime.timedelta(days=1)\n",
    "precompute_data = np.concatenate(data, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dae3fa75-b704-4195-bd02-4f78170dff47",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez_compressed(\"precompute_px_return_BTCFDUSD_5m\", data=precompute_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5e9d45be-e1e7-4801-a15f-7383123b2cdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "precompute_data = np.load(\"precompute_px_return_BTCFDUSD_5m.npz\")[\"data\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b7f29070-da9c-466c-9098-47ea7e669fcb",
   "metadata": {},
   "outputs": [],
   "source": [
    "spot_returns = precompute_data[:, 1]\n",
    "futures_returns = precompute_data[:, 3]\n",
    "m = np.isfinite(spot_returns) & np.isfinite(futures_returns)\n",
    "\n",
    "spot_returns = spot_returns[m]\n",
    "futures_returns = futures_returns[m]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "472e3c54-eda1-4dcf-81e1-bbff0c2b8363",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAksAAAGwCAYAAAC5ACFFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWxUlEQVR4nO3de1xUZf4H8M8MwgygDKDAoCHgJZW8IBqKVpbiZe2Xmq6pqamZlkUXKUtbDa1ctbbM1LKbmbmura7ZRaKQtC2vKXgh0FIxK7moyE0Ehpnn9wfL5MgwzMDMnDnD5/169Wo5c2bO94tgn33Oc55HIYQQICIiIiKzlFIXQEREROTKGJaIiIiILGBYIiIiIrKAYYmIiIjIAoYlIiIiIgsYloiIiIgsYFgiIiIisqCF1AW4A4PBgAsXLqBVq1ZQKBRSl0NERERWEEKgtLQUbdu2hVJZ//gRw5IdXLhwAWFhYVKXQURERI3w22+/4aabbqr3dYYlO2jVqhWAmm+2n59fvefpdDp88803GDZsGDw9PZ1VnlO4c28A+5M7d+7PnXsD2J+cyaG3kpIShIWFGf87Xh+GJTuovfXm5+fXYFjy8fGBn5+fy/7gNJY79wawP7lz5/7cuTeA/cmZnHpraAoNJ3gTERERWcCwRERERGQBwxIRERGRBQxLRERERBYwLBERERFZwLBEREREZAHDEhEREZEFDEtEREREFjAsEREREVnAFbyJiIjI4fQGgUM5hSgorUBwKzViIwPhoZTH5vMMS0RERORQKZm5WPJFFnKLK4zHQjVqJN0ThRHdQyWszDq8DUdEREQOsys7H3M2pZsEJQDIK67AnE3pSMnMlagy63FkiYiIiJqsqtqAj/efw6+F5QgP9MHEvu0AAMu/Oglh5nwBQAFgyRdZGBqldelbcgxLRERE1CTLkrPw3vc5MFyXiv7xdRaW3wrklVSgJhbVJQDkFlfgUE4h4jq2dkqtjcGwRERERI22LDkL7/w3p85xg7nhpHoUlFY0fJKEOGeJiIiIGqWq2oD3vq8blGwV3Epth2och2GJiIiIGuXj/edsGkEyJ1RTs4yAK2NYIiIiokb5tbC8yZ9RXlWN1Kw8O1TjOAxLRERE1CjhgT5N/ozia9V4xMwSAmUV1XhowyHcvuJb/N+b3+Pb7ALomzqM1Uic4E1ERESNMjUuAkuTs5t8Kw4A5m8/gaFRWugNArct24WCqzrja79duYYHP/oRnh4KrJ7U2+kLWXJkiYiIiBrFq4USs26PtMtnFZXrcN/b3+PmhV+ZBKXr6fTC7CiUozEsERERUaPZ887Ykd9KrTpv8edZTr0lx9twREREZJXazXDzSipQWFaJTzN+R+YF6wKOPeWVOHchS4YlIiIiapC5zXCl5MyFLBmWiIiIyKKUzFzM2ZRudo83qThzIUvOWSIiIqJ6VVUb8PynJ1wqKCkApy5kybBEREREZqVk5qL/sjQU1vN0mlRm3R4JD6X5zXkdgbfhiIiIqA5XvPVW67m/dHPq9TiyRERERCb0BoElX2S5ZFBaNyXGqaNKAMMSERERXUdvENiwN8dlnnqrpURNUHL26t0Ab8MRERHR/7ja8gC11k+7FYO6BDl9RKkWwxIREREhJTMXj2xKl7oME11DfJEy906py+BtOCIiouZObxCYv/2E1GWYaO3bwiWCEsCRJSIiomajdruSgtIKBLdSo094AI78egUf7ctBUbnrLA/Qo20rfPHEHVKXYcSwRERE5GZuDEWxkYFIzcqrMx9JAbjUE2/+Kg/8sCAeLdWuFU9cqxoiIiJqEnOTtH28PFBepa9zrisFJQA4tGgYvFq43gwhhiUiIiI3Ud9CkuaCkquZdXukSwYlgGGJiIhIlvQGgQNnLmP/2UsAFOgXGYjFn7vmQpINGRoVjL/dHSV1GfViWCIiInJRtXOP8oqvofBqFQJbqqD1U+PK1So8v+OEyaTsNbslLLQJ3ryvF0bF3CR1GRYxLBEREbkgV10g0p7euj8GI3s6f0VuWzEsERERuRhX3sTWHjTeLbBiXE9Jti5pDIYlIiIiF+LKm9g2Va92fnj2L93Qv0NrybYuaQyGJSIiIhdyKKfQLW+9vXV/b4zs2VbqMhqFYYmIiMiFFJS6V1Aa2qUNVk3pJ6uRpBu55oIGREREzVRwK7XUJdjVykl9ZB2UAIYlIiIilxIbGYhQjbwDUxvfFjj2wjCpy7AbhiUiIiIX4qFUIOke112gsSEzBobj8KLhsh9Nuh7nLBEREbkgjXcLFF+rlroMq7VSKXFk0XCX3bKkKRiWiIiIXEhKZi4e2ZQudRk2uevmIHz4YKzUZTgMwxIREZGL0BsE5m8/IXUZNpl5WwQW/d8tUpfhUAxLRERELuLAmcsm+725MgWAtTJeO8kWDEtEREQuYt+ZS1KXYBWN2gPpL7jXJG5LGJaIiIicTG8QOJRTiILiq8avRbUB3/18UeLKGtZCiWYVlACGJSIiIqdKyczF4s+zkFdSAZWHwCuxQNyyNBRVGiBksCHc44NvblZBCWBYIiIicpr6nnQr1+khhDwCSEQbH6lLcDr3WwyBiIjIBcnxSTdz3G07FmtwZImIiMgJDpyVz5Nu5igAaDVqxEYGSl2K0zEsERERNZFxwnZpBYJb1QSKG+f17D9zWaLq7CfpnqhmN18JYFgiIiJqkpTMXCz5Igu5xRXGY6EaNRbd3Q0BvipjgDIIg4RVNk2oRo2ke6Iwonuo1KVIgmGJiIiokVIyczFnUzpufIgtt7gCj27OMDkW6OvlvMLsaG58ZyQM7twsR5RqMSwRERE1gt4gsOSLrDpBqT5XrlY5tB578/fxxPKxPZrtaNL1GJaIiIhspDcIbNibY3LrrSEyWELJ6K8xN2HFX3s269Gk6zEsERER2cDcHCV3EqpRMyjdgGGJiIjISvXNUXIHtdGouT7xZgkXpSQiIrKCrXOUXJ2/j6fJ11qNGm9PieEcJTM4skRERGSFQzmFbnHrTakA1kyKwfDu2gbXhqIaDEtERERWKCiVf1ACgDcn9MbInjWjR3EdW0tcjTzwNhwREZEV3GFPtIfviMT/RbeVugzZ4cgSERGRFWIjAxGqUcvyVlygrydeHt0dI3syKDUGwxIREZEVPJQKLLq7W52VuV3Z4K5BmHV7R85HaiLZ3YZbu3YtIiIioFar0a9fPxw6dMji+Vu3bkXXrl2hVqvRo0cPJCcnm7y+fft2DBs2DK1bt4ZCocDRo0cdWD0REclZgK9K6hKs9uSQzlg/PRZxHVszKDWRrMLSJ598gsTERCQlJSE9PR29evXC8OHDUVBQYPb8ffv2YdKkSZg5cyYyMjIwZswYjBkzBpmZmcZzrl69ittuuw0rVqxwVhtERCRTcpnkrfVT4YkhnaUuw23IKiy9/vrrmDVrFmbMmIGoqCisW7cOPj4+WL9+vdnzV61ahREjRmDevHno1q0bXnrpJcTExGDNmjXGc6ZOnYoXXngB8fHxzmqDiIhkSg6TvBUAFo+6haNJdiSbOUtVVVU4cuQIFixYYDymVCoRHx+P/fv3m33P/v37kZiYaHJs+PDh2LFjR5NqqaysRGVlpfHrkpISAIBOp4NOp6v3fbWvWTpHrty5N4D9yZ079+fOvQHS9ac3CBz59QoulVWiTUsV+oQHwEOpQO+bWkHbsgWuXLNPPSqlMPl3U2n91Jj/l64Y0qWN5D8TcvjZtLY22YSlS5cuQa/XIyQkxOR4SEgITp48afY9eXl5Zs/Py8trUi3Lli3DkiVL6hz/5ptv4OPj0+D7U1NTm3R9V+bOvQHsT+7cuT937g2Qtr9LAL7O/vPrBT3sf42X+hrs9ElXUZVzBMk5dvo4O3Dln83y8nKrzpNNWHIlCxYsMBmxKikpQVhYGIYNGwY/P79636fT6ZCamoqhQ4fC09Oz3vPkyJ17A9if3Llzf+7cG+D8/nZl52PuJ0frbGlSe0Nr5YRoPPXJUbtdT6UUeKmvAYsOK1FpaNxts/XTbkVsZKDdarIXOfxs1t4ZaohswlKbNm3g4eGB/Px8k+P5+fnQarVm36PVam0631oqlQoqVd0nIjw9Pa36gbD2PDly594A9id37tyfO/cGOKc/vUHgxZ2nUKGvP7TM2XwMf0Yn+6k0KFBp4brmKFCzn1v/TsEuPT/JlX82ra1LNhO8vby80KdPH6SlpRmPGQwGpKWlIS4uzux74uLiTM4HaoYD6zufiIiaLznt/VYbjZLuiXLpoOQuZDOyBACJiYmYNm0a+vbti9jYWLzxxhu4evUqZsyYAQB44IEH0K5dOyxbtgwA8OSTT2LQoEF47bXXcPfdd2PLli04fPgw3n33XeNnFhYW4vz587hw4QIA4NSpUwBqRqWaOgJFRETS0xuEVRvGymVZAKBmRCnpniiM6B4qdSnNgqzC0oQJE3Dx4kW88MILyMvLQ3R0NFJSUoyTuM+fPw+l8s/BsgEDBmDz5s1YuHAhnn/+eXTu3Bk7duxA9+7djed8/vnnxrAFABMnTgQAJCUlYfHixc5pjIiIHCIlMxdLvsgyGTEKrSdotHHBBSdHdg/G8O5ta2pTAJfKKi0GPnIMWYUlAEhISEBCQoLZ1/bs2VPn2Pjx4zF+/Ph6P2/69OmYPn26naojIiJXkZKZizmb0utM1s4rrsCcTel4e0oMhkZpcSinELuy8rDp4HlJ6jRnYIcAfPhgf3i1kM1sGbcmu7BERETUEL1BYMkXWXWCEgAI1Mz5mb/9BBZ/noW8Ete7/XZfbDiDkgthWCIiIrfT0GRtAaCoXAfANRdMlMNK4c0JYysREbkdOU3WvlGoRu2S6yY1ZwxLRETkduQ8MsPlAFwPwxIREbmd2MhA+Pu45kKI9VEqgLfuj+FyAC6IYYmIiNxOalbe/+YkyceaSb0xsieDkitiWCIiIreiNwgs/jxL6jLqFejrVefYGxOiMbJnWwmqIWvwaTgiIpItc6tz7/vlkksuB1Br0d3doNV4o6C0Am18WuBS9gHEdwuRuiyygGGJiIhkydzq3D5eHrhWpZewqoZpNd6I69gaAKDT6ZCcLXFB1CCGJSIikp36Vucud+GgpEDNnm5cFkB+OGeJiIhkxdLq3K6qdiEALgsgTwxLRETkkmrnIwE1K3LrDcL4vy2tzu0KbsxDWo0ab0/hsgByxdtwRETkcmrnIxWWXcMrscCDH/2IwJbeSLonyuXnJCkArJkUgwBfL5OJ5xxRki+GJSIicinXz0dSefx5PLe4Ao9sSoenh+uGjlCNGkn3RHEEyc0wLBERkcuwZj6STu86s5U8PRSY0DcMvcP80TbAhyNIbophiYiIXIYc5iNdb/Wk3hxFagY4wZuIiFxGQak8glKoRo11nLDdbHBkiYiIXEZwK7XUJVjUMcgHL4/pydttzQzDEhERuQS9QWD/mUtSl2HRwE5BxtW3qflgWCIiIqcxt5ebh1KB5OO5mPvvo6isNkhdokXhgT5Sl0ASYFgiIiKnMLeXW6hGjajQVkg7eVHCyqyjVABT4yKkLoMkwLBEREQOV99ebrnFFbJ5+m3W7ZHwasHnopojhiUiInIoOe7ldj2loiYoLRgZJXUpJBGGJSIicig5rZ3k46XEkYXDsPngr/i1sBzhgT6YGhfBEaVmjmGJiIgcSi5rJwHA6/dFw9vLAzNv7yB1KeRCGJWJiMihXH3tJKBm89u37ucik2QewxIRETmM3iDwakq21GU0aPXE3hjZk0GJzONtOCIiMlG7FlJe8TUUXq1CYEsVtH5qm1at1hsE1nx7Gmu+/Rk61146Cf07BOL/ottKXQa5MIYlIiIyMrcWUq1QjRpJ90SZ3Koyt8hkalYe5m8/gaJynTNLbxQFgI0P9pO6DHJxDEtERASg/rWQauUWV+CRTelYMzEa/xfdzmyw8vFUotzVh5KuM/sOrp1EDWNYIiIim9ZCSthyFOv3nUP6+aI6r8klKClQE5S4dhJZg2GJiIhsXgvJXFCSC5WHAkeThsPby0PqUkgmOPZIRESyWgupqSr1Akd/K5K6DJIRhiUiIpLFWkj21JzCITUdwxIREaFPeACsWxTAPTS3cEhNwzlLRESEI79eke1Gt7ZQANBqapY4ILIWR5aIiKhZ3JaqHTlLuifK6sU1iQCOLBEREYBzl8qlLsHhtGYW1SSyBsMSEVEzVrstycpdP0tdil0pFMCDAyMR3y3EZHVxjihRYzAsERE1UymZuVj8+U/IK6mUuhS7EwJY/0MObo0IwOjodlKXQzLHOUtERM1Q7dYm7hiUrrfkiyzoDc1h6jo5EsMSEVEzY8vWJnImULOf3aGcQqlLIZljWCIiamZs3drE1UyLa49/zeqPB+LCrTq/OTzpR47FsERE1MzIPTyM6N4WcR1b4y9WPtXGBSipqTjBm4jIjekNAodyCnHhSjmO/l6EmtWG5HsDTqmoWW0cAGIjAxGqUSOvuMJsR1yAkuyFYYmIyE2lZOZiyRdZsr7ldiODqFltPK5ja3goFUi6JwpzNqXXiYBcgJLsibfhiIjcUO3Tbu4UlGpdfxtxRPdQvD0lBlqN6a02rUaNt6fEcAFKsguOLBERuRl3f9rtxjlII7qHYmiUFodyCrkAJTlEk8OSXq/HiRMnEB4ejoCAAHvURERETSD3p93qY2kOkodSgbiOrZ1fFDULNt+Ge+qpp/DBBx8AqAlKgwYNQkxMDMLCwrBnzx5710dERDZ67/szUpdgd5yDRFKyOSxt27YNvXr1AgB88cUXyMnJwcmTJzF37lz87W9/s3uBRERkveTjufj25EWpy7C7ED/OQSLp2Hwb7tKlS9BqtQCA5ORkjB8/HjfffDMefPBBrFq1yu4FEhGRqdrlAApKK9DGp4XJ8Wf/c1zCyuxDqQBm3haJwV1DUFB8FfgtA18/dQfUKi+pS6NmyuawFBISgqysLISGhiIlJQVvv/02AKC8vBweHh52L5CIiP5043IAKg+BV2KBXdn58PNRo6yyWuIKGyc2IgBdQ/0QHuiDqXER8GpRc+NDp/ND8m8ZvPVGkrI5LM2YMQP33XcfQkNDoVAoEB8fDwA4ePAgunbtavcCiYioRu1yAOaecnvqk6O4KbCl02uyl7lDu3CCNrksm8PS4sWL0b17d/z2228YP348VCoVAMDDwwPz58+3e4FERGTdcgBnLl51Wj32FMpVtsnFNWrpgL/+9a91jk2bNq3JxRARUV16g8CGvTluuxwAn3AjV9eosJSWloa0tDQUFBTAYDCYvLZ+/Xq7FEZERO65ZUktrZ8Ki0fdwifcyOXZHJaWLFmCF198EX379jXOWyIiIvuzNEfJHbx2XzQGdmojdRlEDbI5LK1btw4bNmzA1KlTHVEPERHB/bcsAYBLZZVSl0BkFZsXpayqqsKAAQMcUQsREf2Pu25Zcr0b93gjclU2h6WHHnoImzdvdkQtRET0PwWl7huUFOATcCQvNt+Gq6iowLvvvotdu3ahZ8+e8PT0NHn99ddft1txRETu5PqVt4Nb1YQFc0+B6Q0Cl0rd8xYV93gjObI5LB0/fhzR0dEAgMzMTJPXONmbiMg8c0+1hWrUSLonyuRpMHd6+k3tqYTa0wNF5TrjMa2ZnolcnU1hSa/XY8mSJejRowcCAgIcVRMRkVup76m23OIKPLIpHbd3bg11Cw9U6vT47+nLktRob4G+njiwIB4eSoVVo2lErsymsOTh4YFhw4YhOzubYYmIyArWPNX2/S/uEZCAP2+z/f3eHsb93biNCcmdzRO8u3fvjrNnzzqiFiIit9Mcnmq7nlajxttTYnibjdyKzXOWXn75ZTzzzDN46aWX0KdPH/j6+pq87ufnZ7fiiIjkzp2fagOAcb3bYmyfMFwqq+RtNnJbNoelkSNHAgBGjRplMqFbCAGFQgG9Xm+/6oiIZM6d1xLy9/HEK+OjGY7I7dkclnbv3u2IOoiI3FJsZCD8vT1RdE3X8Mkys3xsDwYlahZsnrM0aNAgi/842tq1axEREQG1Wo1+/frh0KFDFs/funUrunbtCrVajR49eiA5OdnkdSEEXnjhBYSGhsLb2xvx8fH45ZdfHNkCETUjHkoFZgyMkLoMu1IqgLfu57wkaj5sDkv//e9/Lf7jSJ988gkSExORlJSE9PR09OrVC8OHD0dBQYHZ8/ft24dJkyZh5syZyMjIwJgxYzBmzBiT9aFeeeUVvPnmm1i3bh0OHjwIX19fDB8+HBUV7j3PgIicJ2FwZ/j7eDZ8okysmdQbI3syKFHzYfNtuDvvvLPOsevnLjlyztLrr7+OWbNmYcaMGQBqNvXduXMn1q9fj/nz59c5f9WqVRgxYgTmzZsHAHjppZeQmpqKNWvWYN26dRBC4I033sDChQsxevRoAMDGjRsREhKCHTt2YOLEiWbrqKysRGXln6vrlpSUAAB0Oh10uvqH2mtfs3SOXLlzbwD7kztX6G9Sn1Cs3/er3T9XpRQm/3a0x+7siKHdgpz2vXSFPztHcuf+5NCbtbUphBA2/YYVFxfXuVBGRgYWLVqEpUuXYsiQIbZ8nNWqqqrg4+ODbdu2YcyYMcbj06ZNQ1FRET777LM672nfvj0SExPx1FNPGY8lJSVhx44dOHbsGM6ePYuOHTsiIyPDuCo5UHOrMTo6GqtWrTJby+LFi7FkyZI6xzdv3gwfH59G90hERETOU15ejvvvvx/FxcUWn+a3eWRJo9HUOTZ06FB4eXkhMTERR44csfUjrXLp0iXo9XqEhISYHA8JCcHJkyfNvicvL8/s+Xl5ecbXa4/Vd445CxYsQGJiovHrkpIShIWFYdiwYRa/2TqdDqmpqRg6dGidPfXkzp17A9if3NmjP71B4MivV3CprBJtWqrQJzyg3n3das/79mQBUn6q/+8Se1ApBV7qa8Ciw0pUGhwz2br2U1dOiEZ8txCL59obfzblSw691d4ZaojNYak+ISEhOHXqlL0+zqWpVCqoVKo6xz09Pa36gbD2PDly594A9id31vZ344a3V65W4aWdlvd1q6o2YMH2Y/jyeC4qq68fsHfO02KVBgUq9Y65lrk97JyNP5vy5cq9WVtXozbSvZ4QArm5uVi+fLnJrSx7a9OmDTw8PJCfn29yPD8/H1qt1ux7tFqtxfNr/52fn4/Q0FCTcxzZCxG5Lms3ss0rrsCcTel4e0oMMs5fwbv/zbG4pYkcJdzVCQM7teFCk9Ts2RyWoqOjoVAocONUp/79+2P9+vV2K+xGXl5e6NOnD9LS0oxzlgwGA9LS0pCQkGD2PXFxcUhLSzOZs5Samoq4uDgAQGRkJLRaLdLS0ozhqKSkBAcPHsScOXMc1gsR2d+No0Hm/gOvNwgc+uUS9p+9BECBuI6t0b9Da+N59W14a45AzZjR01uP4Wql+y3GG6pRY+7QmxmSiNCIsJSTk2PytVKpRFBQENRqx69Sm5iYiGnTpqFv376IjY3FG2+8gatXrxqfjnvggQfQrl07LFu2DADw5JNPYtCgQXjttddw9913Y8uWLTh8+DDeffddADVP8T311FN4+eWX0blzZ0RGRmLRokVo27atySRyInJt5kaDzN06GvTqbuSXVRu/XrP7NPx9PLF8bA8MjdI2uOHtjQTglkEJAJLuiWJQIvofm8PSd999hwkTJtSZs1NVVYUtW7bggQcesFtxN5owYQIuXryIF154AXl5eYiOjkZKSopxgvb58+ehVP65dNSAAQOwefNmLFy4EM8//zw6d+6MHTt2oHv37sZznn32WVy9ehWzZ89GUVERbrvtNqSkpDgl/BFR09U3GnT9bTJhqAk0NatomwaAonIdHtmUjrnxnZvVhrf18VV54LXxvbjgJNF1bA5LM2bMwIgRIxAcHGxyvLS0FDNmzHBoWAKAhISEem+77dmzp86x8ePHY/z48fV+nkKhwIsvvogXX3zRXiUSkZPoDaLe0aDa22SLP/8JngqBZ6Isf9aHe8/Zv0AZenlMDwYlohvYHJZqN8y90e+//252WQEiIkc5lFNocTRIAMgrqYTKo+Gba+64d1tjaP04qk50I6vDUu/evaFQKKBQKDBkyBC0aPHnW/V6PXJycjBixAiHFElEZE5BqX1vm2m8PVHcjENTqKZmYjwRmbI6LNVOeD569CiGDx+Oli1bGl/z8vJCREQExo0bZ/cCiYjqE9zKvqMgeoO7PfxvPQU4qZuoPlaHpaSkJABAREQEJkyYwAnQRCS52MhAhGrUyCuuMDtvSQEgxE8FT4UAUN7g55VVVjd4jjtyhUUniVyZzXOWavdi27RpE86cOYN58+YhMDAQ6enpCAkJQbt27RxRJxFRHR5KBZLuicKcTelQADC3bvbiUbdAGPSoynHMVkxy5e2pxMRbwzDsllAuOknUgEat4B0fHw+NRoNz585h1qxZCAwMxPbt23H+/Hls3LjREXUSEZk1onso3p4SU2edJe11oyU6nQ7JOYC/t6fJOksAoPZUokJncHbZkvH38cSMAZFIGNyJAYnISjaHpblz52L69Ol45ZVX0KpVK+PxkSNH4v7777drcURE1hjRPRRDo7QNruD93by7cOR8CfafvYQzF6/iwJlLuHLNfW+91Y62zY3vjIg2vvV+X4jIMpvD0vUrYF+vXbt2yMtz7O7aRET18VDWbF/S0DkDO7dBaaUOa3afcVJl0tFyLhKRXdgcllQqFUpKSuoc//nnnxEUFGSXooiIHEVvEJi//YTUZTiUv48n1k6KQf+OrTmKRGQHyoZPMTVq1Ci8+OKL0Olq1iJRKBQ4f/48nnvuOS4dQEQu78CZyygqd8+1lBT/+2f52B4Y2LkNgxKRndgcll577TWUlZUhODgY165dw6BBg9CpUye0bNkSS5cudUSNRER2s//sJalLcBitRo23p8TwthuRndl8G06j0SA1NRU//PADjh8/jrKyMsTExCA+Pt4R9RER2Zl7jrY8fHsknhzGRSWJHMHmsFTrtttuw2233Wb8Oj09HS+88AK+/PJLuxRGROQIcR1bY83u01KXYXf9OvC2G5Gj2HQb7uuvv8YzzzyD559/HmfPngUAnDx5EmPGjMGtt94Kg6H5rFVCRPJzKKcQBSUVaKlq9P9PdDm18ahPeICkdRC5M6v/xvjggw+MC1BeuXIF77//Pl5//XU8/vjjmDBhAjIzM9GtWzdH1kpE1Ci7svMBAA9+9CMq9e4z+nJ9JxxVInIcq0eWVq1ahRUrVuDSpUv497//jUuXLuGtt97CiRMnsG7dOgYlInJJKZm5mPvJUanLcAitRo2VE6KlLoPI7Vk9snTmzBmMHz8eADB27Fi0aNECr776Km666SaHFUdE1BR6g8CSL7LMbrIrd4G+nvhu3l1QCD2Sc6Suhsi9WT2ydO3aNfj4+ACoWVtJpVIhNJSPpxKR6zqUU2iyX5w7Kbyqw5Ffr0hdBlGzYNMsx/fffx8tW7YEAFRXV2PDhg1o06aNyTlPPPGE/aojImqCglL3DEq1avrzk7oMIrdndVhq37493nvvPePXWq0WH3/8sck5CoWCYYmIXMa5S+VSl+BQwa3UUpdA1CxYHZbOnTvnwDKIiOxLbxBYv/es1GU4hAI1k7tjIwNh0FdLXQ6R27N5uxMiIlenNwhMee8giq+5X5CoXSAg6R6u1k3kLO6zMhsREWqWCpj/n+MocsOgBNSMKCXdE8X934iciGGJiNxCVbUBz28/jm3pf0hdikMk3NURAzsFITYykCNKRE7GsEREsrd0Zxbe/yEHwh0XVAIQqlFj7tAuDElEEmFYIiJZm7XxR6RmFUhdhsMowPlJRFKzeYJ3eno6Tpw4Yfz6s88+w5gxY/D888+jqqrKrsUREVny5dE/3DoohWrUeHtKDOcnEUnM5pGlhx9+GPPnz0ePHj1w9uxZTJw4Effeey+2bt2K8vJyvPHGGw4ok4jIlN4gsGDHiYZPlBGNdwsk3NUZbVqpoPVTc34SkYuwOSz9/PPPiI6OBgBs3boVd9xxBzZv3oy9e/di4sSJDEtE5BSHcgpRWqGXugy7WjGuJ0eRiFyQzbfhhBAwGAwAgF27dmHkyJEAgLCwMFy6dMm+1RER1eObn3KlLsFulArgrft5u43IVdkclvr27YuXX34ZH3/8Mb777jvcfffdAICcnByEhITYvUAiohst3fkTPtz3q9Rl2M2aSb0xsieDEpGrsjksvfHGG0hPT0dCQgL+9re/oVOnTgCAbdu2YcCAAXYvkIjoei9/8RPe+/6c1GXYLMDHE/7enibHQjVqrJsSg5E920pUFRFZw+Y5Sz179jR5Gq7Wq6++Cg8PD7sURUR0vapqAzbszcG735/BpTKd1OVYLdDXE4v+7xZo/dS4crUSL36ZBVz783XhrgtDEbmZRu0NV1RUhPfffx8LFixAYWEhACArKwsFBe77CC8RSWNZcha6LPwKf//qpKyCEgAUXtVB66dG8bUqPLY5A3kllSav55dUYs6mdKRkus/8KyJ3ZPPI0vHjxzFkyBD4+/vj3LlzmDVrFgIDA7F9+3acP38eGzdudESdRORm9AaBQzmFKCitQHAr84/JL0vOwjv/zZGoQvvIK76GV74+BXNjSAI1i04u+SILQ6O0XCaAyEXZHJYSExMxY8YMvPLKK2jVqpXx+MiRI3H//ffbtTgick8pmblY8kUWcosrjMdCb9gg9lqVHu9+L++gBACFV6tM+ryRAJBbXIFDOYWI69jaeYURkdVsDks//vgj3nnnnTrH27Vrh7y8PLsURUTuKyUzF3M2pdcZackrrsCcTel4e0oMDAYg4V/pst7rTQFAq1EjsKXKqvMLSusPVEQkLZvDkkqlQklJSZ3jP//8M4KCguxSFBG5J71BYMkXWfXekgKAxzdnQGeQcUpCTVACavZ003h7WfWe4FZqxxVERE1i8wTvUaNG4cUXX4ROVzPRUqFQ4Pz583juuecwbtw4uxdIRO7jUE6hxVtSAGQflICaEaXaPd1iIwMRqlGjvtlICtTcgoyNDHRmiURkA5vD0muvvYaysjIEBwfj2rVrGDRoEDp16oRWrVph6dKljqiRiNzEriz3vlU/fUA4/jWrP354brBx7pWHUoGke6IAoE5gun4EipO7iVyXzbfhNBoNUlNTsXfvXhw7dgxlZWWIiYlBfHy8I+ojIjehNwh8evQPqctwmIfviMSCkVFmXxvRPRRvT4mpM6lde8OkdiJyTTaFJZ1OB29vbxw9ehQDBw7EwIEDHVUXEbmJ2iUCvv+lAIVX5bVOUq0AH08sG9sDAOoEnta+XnhpdPcGtysZ0T0UQ6O0DS6XQESux6aw5Onpifbt20Ovd6+dvonIetasj1TL3BIBcuLj5YGH7+iAhMGdjT02JfB4KBVcHoBIhmy+Dfe3v/0Nzz//PD7++GMEBnJCIlFzYs36SNefa26JADnw9/HEjAGRSBjcqU4QYuAhan5sDktr1qzB6dOn0bZtW4SHh8PX19fk9fT0dLsVR0Suw5r1kWoDk6UlAlyRAjVLFzw4MAJDo7S8PUZEJmwOS2PGjHFAGUTkyhpaH+nGLTsOnLksq1tvnGhNRJbYHJaSkpIcUQcRubCG1keq3bJjZerP8PRQYP0Prr9NyaK7u6FNKxUnWhNRg2wOS0TU/Fi7Fcea3acdXIn9tGmlwujodlKXQUQyYHNYUiqVUCjq/39gfFKOyP2441Yc7tgTETmGzWHp008/Nflap9MhIyMDH330EZYsWWK3wojIddRu2ZFXXCGbSduWBPp6cnsRIrKazWFp9OjRdY799a9/xS233IJPPvkEM2fOtEthROQ6arfsmLMp3fjkmJzdG92Oc5SIyGo27w1Xn/79+yMtLc1eH0dELqZ2yw6tRv63r+KjtFKXQEQyYpewdO3aNbz55pto146TJYnc2YjuofjhucFYdHc3qUtpNK2firfgiMgmNt+GCwgIMJngLYRAaWkpfHx8sGnTJrsWR0Su6Up5ldQlNNriUbfwFhwR2cTmsLRy5UqTsKRUKhEUFIR+/fohICDArsURkevQGwRWp/2C9344i6uVrv3Uq0IBCDMTq96YEM2FJ4nIZjaHpcGDByMsLMzs8gHnz59H+/bt7VIYEbmOlMxcPP3vY7haJW1IenpIZ0SHB2DPqQJ8sPdcnddr/1ZaO6k3ND5e2H/mMgCBfuH+KDx1EPHdQpxZLhG5CZvDUmRkJHJzcxEcHGxy/PLly4iMjOQ6S0QyojcIHMopREHxVQDAgbOXUXhNj+BWakSH+WPDvhxs3JeD3BLpb7s9fEckHh96MwDg9puDcGtkYJ1NfW/ctmRgpzYAapY4ST7l/JqJyD3YHJaEubFtAGVlZVCr5f+UDFFzkZKZawwbKg+BV2KBhzYeRqXe9ebzPHxHJBaMjDI5NqJ7KIZGaWvCXmkFty0hIoexOiwlJiYCABQKBV544QX4+PgYX9Pr9Th48CCio6PtXiAR2V9KZi7mbEp3+fWSxvZuh+XjesKrhfkHdz2UCsR1bO3kqoioubE6LGVkZACoGVk6ceIEvLy8jK95eXmhV69eeOaZZ+xfIRHZld4gsOSLLJcPSm/d3xsje7aVugwiIuvD0u7duwEAM2bMwKpVq+Dn5+ewoojIcQ7lFJrM83FFc+M7MygRkcuwec7Shx9+6Ig6iMhJCkpdOyiFatRIGNxZ6jKIiIwatXSAJd9++22jiyEix6qqNuDwuUKpy7Ao6Z4oTtImIpdic1jq1auXydc6nQ5Hjx5FZmYmpk2bZrfCiMi+liVn4b3vc2Bw0clKAT6eWDa2BxeNJCKX06gVvM1ZvHgxysrKmlwQEdmHcQ2l0gp881Medp7Ik7oks3w9lVg3tS8GdGrDESUickk2h6X6TJkyBbGxsfjHP/5hr48kokZKyczF4s+zkFfi2vOTAOCqzoAWHkoGJSJyWXYLS/v37+eilEQS0hsEDpy9jE0HfsVXma45ilQfV590TkTNm81haezYsSZfCyGQm5uLw4cPY9GiRXYrjIisl3w8F8/+5zjKKqulLqVRglvx/2gRkesyvyyuBRqNxuSfwMBA3HnnnUhOTkZSUpIjagQAFBYWYvLkyfDz84O/vz9mzpzZ4BypiooKPPbYY2jdujVatmyJcePGIT8/3+ScJ554An369IFKpeIK5CQ7VdUGTHp3Hx7dnC7LoKRAzVIBsZGBUpdCRFQvq0eWzp49i8jISMnWWZo8eTJyc3ORmpoKnU6HGTNmYPbs2di8eXO975k7dy527tyJrVu3QqPRICEhAWPHjsXevXtNznvwwQdx8OBBHD9+3NFtENnNsuQsvPt9DurZrtHl1c5Q4lIBROTqrB5Z6ty5My5evGj8esKECXVGaRwlOzsbKSkpeP/999GvXz/cdtttWL16NbZs2YILFy6YfU9xcTE++OADvP766xg8eDD69OmDDz/8EPv27cOBAweM57355pt47LHH0KFDB6f0QmQPy5Kz8M5/XT8o3d6pNV77a0/8NaYdNN6m/99Mq1Hj7SkxXCqAiFye1SNL4oa/lZOTk7Fs2TK7F2TO/v374e/vj759+xqPxcfHQ6lU4uDBg7j33nvrvOfIkSPQ6XSIj483HuvatSvat2+P/fv3o3///o2up7KyEpWVlcavS0pKANSsOaXT6ep9X+1rls6RK3fuDXCt/qqqDdi47yxUHvb7TJVSmPzbHnxaKPHe1Bh4KBUY1UuLl0dH4civV3CprBJtWqrQJzwAHkqFU76nrvTnZ2/u3BvA/uRMDr1ZW5vdnoZzpLy8PAQHB5sca9GiBQIDA5GXZ/6pn7y8PHh5ecHf39/keEhISL3vsdayZcuwZMmSOse/+eYb+Pj4NPj+1NTUJl3flblzb4Dr9Lf8Vsd87kt9DXb8ND2+TvnK7CuXAHydbcdLWclV/vwcwZ17A9ifnLlyb+Xl5VadZ3VYUigUUCgUdY41xfz587FixQqL52RnS/A3agMWLFiAxMRE49clJSUICwvDsGHDLG4wrNPpkJqaiqFDh8LT09MZpTqNO/cGuFZ/S5Oz8a9D5+36mSqlwEt9DVh0WIlKQ9PnD/l6eaClqgXyS/8cgdX6qTH/L10R3y2kyZ9vK1f687M3d+4NYH9yJofeau8MNcSm23DTp0+HSqUCUPOk2SOPPAJfX1+T87Zv3251kU8//TSmT59u8ZwOHTpAq9WioKDA5Hh1dTUKCwuh1WrNvk+r1aKqqgpFRUUmo0v5+fn1vsdaKpXK+H24nqenp1U/ENaeJ0fu3BvgGv2VVuhRqXfMhOhKg8Iun115zYDCa1X4cxo3cP5KJR7dfEzSeUqu8OfnKO7cG8D+5MyVe7O2LqvD0o37vk2ZMsW2iswICgpCUFBQg+fFxcWhqKgIR44cQZ8+fQDUbNhrMBjQr18/s+/p06cPPD09kZaWhnHjxgEATp06hfPnzyMuLq7JtRNJQW8Q+PbUxYZPdEECNdFpyRdZGBql5RNwRCQbVoclqZYMAIBu3bphxIgRmDVrFtatWwedToeEhARMnDgRbdu2BQD88ccfGDJkCDZu3IjY2FhoNBrMnDkTiYmJCAwMhJ+fHx5//HHExcWZTO4+ffo0ysrKkJeXh2vXruHo0aMAgKioKHh5eUnRLlG9DuUU4kq5606WbIgAkFtcgUM5hYjr2FrqcoiIrCKLCd4A8M9//hMJCQkYMmQIlEolxo0bhzfffNP4uk6nw6lTp0wma61cudJ4bmVlJYYPH4633nrL5HMfeughfPfdd8ave/fuDQDIyclBRESEY5sispG7bAviLn0QUfMgm7AUGBhocQHKiIiIOssbqNVqrF27FmvXrq33fXv27LFXiUQO5y7bgrhLH0TUPNi83QkRSefK1UrIeaYPtzchIjliWCKSiZTMXDy6OQNSLNrdUqVsckjj9iZEJFcMS0QyoDcIzN9+QrLr9w2vGQlqSsTh9iZEJFeymbNE1Jy9mfYLiiR8Cm5gpyD0bh+AD/eeQ9G1P+sI1agxqlcoPj+Wi9ziCpPji+6OQoCvFwpKKxDcqubWG0eUiEiOGJaIXNi1Kj1mrj+EfecKJatBAeD9788gv7TKeMzf2xMzBkYiYXAneCgVeHZENxzKKWQwIiK3xLBE5KJmbjiEtJPSL0ApAJOgBABF13RYuetndNG2xIjuofBQKrhuEhG5LYYlIhehNwjj6Mzfd2bVCShSaKFUoNpQ/5Ty+dtPcDVuInJ7DEtELiAlMxdLvsgymffjCiwFJQAoKtdhzben8WR8ZydVRETkfHwajkhiKZm5mLMp3eWCkrU+3JcDfQOhiohIzhiWiCSkNwgs+SJLkrWT7KWoXIdDOdJNQCcicjSGJSIJHcopdOkRJV8vD6vO415vROTOGJaIJJSSeUHqEuoVqlHjodsjrTqXe70RkTtjWCKSyLLkLHy0/7zUZdQr6Z4oPDHkZvj7eNZ7Dvd6I6LmgGGJSAJfHr2Ad/6bI3UZZgX4eGLd/7Yl8VAqsHxsD7PbnHCvNyJqLrh0AJGTfXb0Dzy55ajUZQAAAn29cGtEAFp6KgD8jvcf6IsBnUNMws+I7qF4e0pMnaUNtBo1ku6J4l5vROT2GJaInKSq2oCRq77D6YvlUpcCAJjavz0Wj+oOD6UCOp0Oycm/o3+H1mZHiUZ0D8XQKC23NCGiZolhichBalfkziu+hk9+/BUHcoqkLslETPsAm8IOtzQhouaKYYnIAVx1Re7raTXeUpdARCQLnOBNZGdSrcgdqlHj4TsiofVr+DF+PsFGRGQ9jiwR2ZEUK3LPGBCOYbeEGucQPTuiG9Z8+wtW7vrF7PkK8Ak2IiJbMCwR2dGBM5edOqL08B2RWDAyyuSYh1KBJ+NvRhdtqzq3AkP5BBsRkc0Ylojs5NP03zH338eccq3Wvl54aXR3jOxZf+jhE2xERPbBsERkB7evSMNvV5wzohTo64n9C4bAq0XDUw75BBsRUdNxgjdRE938/E6nBSUAKLyqw5FfrzjtekREzR1HloiaoPOCndA5czb3/xSUuu6SBERE7oYjS0SN1GVhsiRBCQCCWzW8PAAREdkHR5aIGuHm53eiyiDNtblGEhGRc3FkicgGVyurETFfuqAEcI0kIiJnY1giaoDeILD/9CUAQL9laZLW8tSQzlwjiYjIyXgbjsiClMxcJP77GPT6arwSK20t/t4t8PiQztIWQUTUDDEsEdUj+fgFPLo5AwCg8pC4GADLx/Xk7TciIgkwLBHd4FqVHg999CP2nrksdSkAuEUJEZHUGJaIUDMv6cCZy/jbjhM4d7lcsjr8fTzx9zE9EODrxS1KiIhcBMMSNXvJxy9g3rbjuFqll6wGHy8PPHxHRyQM7sRgRETkYhiWqFlbujML732fI2kNH02/FbfdHMSQRETkohiWqNl66cuf8MEP5ySt4a6uQRjUNVjSGoiIyDKGJWpW9AaBfb9cwqLPjuNcofT7q82+vaPUJRARUQMYlsjt6A0Ch3IKkVdSgcKySgT6ekGr8caVq5V4eusxXNNJuPz2dbhtCRGRPDAskVtJyczFki+ykFss/ahRfWpnJnHbEiIieWBYIreRkpmLOZvSIaQupAFarptERCQrDEvkFvQGgSVfZDk1KCkVwKzbI/H0sK74eP85/FpYjvLKavxw+hLySiqN54Vq1Jh4a3tEtPHhuklERDLEsERu4VBOodNuvfW6SYNRvdpialwEvFrU7EU98/YOxtdr50xxUUkiIvfAsERuoaDUOUGpjU8LbH90oMXw46FUIK5ja6fUQ0REjqeUugAiewhupXbKdRbe052jREREzQxHlkjWam95TXrvgEOv4+WhBKBHfLcQh16HiIhcD8MSyVZKZi5e2JGJgrIqh11DqQA+mNIXcZ0C8HXKVw67DhERuS6GJZKl5OMX8OjmDIdf563JMbjrlhDodDqHX4uIiFwTwxLJit4gsDrtF7yR9ovDr/XW/TFcC4mIiBiWSD6Sj+di3rZjuFqld/i13rq/N0b2ZFAiIiKGJZKJpTt/wnvfn3P4dVQtFFg1sTdHlIiIyIhhiVya3iAwZ+MhfHPyksOvpVEp8eOi4caFJomIiACGJXJhn2X8gSc/Oeq0660YH82gREREdTAskUv6vze/Q+aFMqdcS9VCiVUTo3nrjYiIzGJYIpczcHkq/ihy3NpJ12ul8sCRRcM4okRERPViWCLJVVUb8P5/z2Dj/rPIK6126rVXjOvFoERERBYxLJFk9AaBxzcfQXJmviTXf/iOSC4PQEREDWJYIkmkZObisX+mQy+cf21flQdeHdcTI3u2df7FiYhIdhiWyOlSMnPxyKZ0p13Px1OJ7u00uDUyEAM6tEH/jq3hoVQ47fpERCRvDEvkVGUV1U4LSnd1CcLsOzoiNjKQ4YiIiBqNYYmcZtbGH5GaVeDw67RUeeAV3mYjIiI7YVgip5i54SDSHLgK96ieWtwU6IuBndqgfwfeZiMiIvthWCKHW/x5psOCkhLA2eV3O+SziYiIAIYlsjO9QeDwmcsoKK1AcCs1PvjhDHZlX3TItbyUwM9/Z1AiIiLHYlgiuxr+xn/x65VKh19ncv+bsHRML4dfh4iIiGGJ7GJXds3CknklFQAcN1/IUwH89NJfuOo2ERE5Df+LQ02mNwgs/+qkU6618aH+DEpERORU/K8ONdmBs5f/N6LkWKEaNWIjAx1+HSIiousxLFGTpGTmYtbGww6/jgJA0j1RXBKAiIicjnOWqNGu37ZE5eG464Rq1Ei6JwojunPTWyIicj7ZjCwVFhZi8uTJ8PPzg7+/P2bOnImysjKL76moqMBjjz2G1q1bo2XLlhg3bhzy8//c4f7YsWOYNGkSwsLC4O3tjW7dumHVqlWObsUtVFUb8Ng/HbdtidpTiRkDIvCvWf3xw3ODGZSIiEgyshlZmjx5MnJzc5GamgqdTocZM2Zg9uzZ2Lx5c73vmTt3Lnbu3ImtW7dCo9EgISEBY8eOxd69ewEAR44cQXBwMDZt2oSwsDDs27cPs2fPhoeHBxISEpzVmuwkH7+Ax7dkQC/s/9kRrX2w9N4eXIWbiIhchizCUnZ2NlJSUvDjjz+ib9++AIDVq1dj5MiR+Mc//oG2bevuAVZcXIwPPvgAmzdvxuDBgwEAH374Ibp164YDBw6gf//+ePDBB03e06FDB+zfvx/bt2+3GJYqKytRWfnnWkIlJSUAAJ1OB51OV+/7al+zdI6re/2bk1i/71e0UAAtrrv1plIKk383xsEFQ+CrqvmRNOirYdA3qVS7coc/O0vYn3y5c28A+5MzOfRmbW0KIYQDxgfsa/369Xj66adx5coV47Hq6mqo1Wps3boV9957b533fPvttxgyZAiuXLkCf39/4/Hw8HA89dRTmDt3rtlrTZkyBRUVFdi2bVu99SxevBhLliypc3zz5s3w8fGxoTMiIiKSSnl5Oe6//34UFxfDz8+v3vNkMbKUl5eH4OBgk2MtWrRAYGAg8vLy6n2Pl5eXSVACgJCQkHrfs2/fPnzyySfYuXOnxXoWLFiAxMRE49clJSUICwvDsGHDLH6zdTodUlNTMXToUHh6elq8hqupqjYgdmkqquuJ1iqlwEt9DVh0WIlKg223zx67syPm3NnJDlU6jpz/7KzB/uTLnXsD2J+cyaG32jtDDZE0LM2fPx8rVqyweE52drZTasnMzMTo0aORlJSEYcOGWTxXpVJBpVLVOe7p6WnVD4S15zlTVbUBH+8/h18LyxEe6IOpcRHwaqGE3iDwZtrPeDPtNIQVK3NXGhSo1FsflkI1ajw2pKts5ie54p+dPbE/+XLn3gD2J2eu3Ju1dUkalp5++mlMnz7d4jkdOnSAVqtFQUGByfHq6moUFhZCq9WafZ9Wq0VVVRWKiopMRpfy8/PrvCcrKwtDhgzB7NmzsXDhwkb1ImfLkrPw3vc5MFw3arQ0ORtDugVj7+nLKK9y3OQhrp1ERESuTtKwFBQUhKCgoAbPi4uLQ1FREY4cOYI+ffoAqJmTZDAY0K9fP7Pv6dOnDzw9PZGWloZx48YBAE6dOoXz588jLi7OeN5PP/2EwYMHY9q0aVi6dKkdupKXZclZeOe/OXWOGwSQmlVg5h32EeDjiWVje3BJACIicnmymLPUrVs3jBgxArNmzcK6deug0+mQkJCAiRMnGp+E++OPPzBkyBBs3LgRsbGx0Gg0mDlzJhITExEYGAg/Pz88/vjjiIuLQ//+/QHU3HobPHgwhg8fjsTERONcJg8PD6tCnNxVVRvw3vd1g5IjdQryxZLR3bk0ABERyYYswhIA/POf/0RCQgKGDBkCpVKJcePG4c033zS+rtPpcOrUKZSXlxuPrVy50nhuZWUlhg8fjrfeesv4+rZt23Dx4kVs2rQJmzZtMh4PDw/HuXPnnNKXlD7ef87k1pujabxb4Ou5gxiSiIhIVmQTlgIDAy0uQBkREYEbV0FQq9VYu3Yt1q5da/Y9ixcvxuLFi+1Zpqz8Wlje8El2tGJcTwYlIiKSHdlsd0L2Fx7onDWhlArgrftjOD+JiIhkSTYjS2Q/eoPAoZxC+Pt4OeV6ayb1xsieDEpERCRPDEvNTEpmLpZ8kYXc4gqHXytUo0bSPVEcUSIiIlljWGpGUjJz8cimdKdc6y/dQ7Dm/j6co0RERLLHOUvNhN4gMH/7Cadd74G4SAYlIiJyCwxLzcQbu35GUblzdn5u7euF2MhAp1yLiIjI0XgbrhlYujPLqYtPvjS6O0eViIjIbTAsuTG9QeCpLen44nie06754IBwPvlGRERuhWHJTaVk5mLx51nIK3H8U29AzV5vgB6Jw7o65XpERETOwrDkZqqqDXj23xnY4aTRpAcHRmBolBa9b2qFr1O+cso1iYiInIlhyU3oDQJzNv2Ib7IuOuV6N66hpNM5Z/I4ERGRszEsyZzeILBq189489vTTrvm3PjOSBjcmZO4iYioWWBYkrGUzFw8seUoqqoNTrmev7cnlo/rwRW5iYioWWFYkiG9QeDNtJ+xKs15o0kAsHZyDAZ2auPUaxIREUmNYUlmko9fwLxtx3G1Su+0ayoAaDVq9O/Q2mnXJCIichUMSzIhxZpJQE1QAoCke6I4R4mIiJolhiUZSMnMxfz/nEDRNcc/cebv3QJF16qNX2tveOqNiIiouWFYcnEpmbl4ZFO6w6+jUXtgxV97YWiUFodyClFQWoHgVmrERgZyRImIiJo1hiUXpjcIzN9+winXmtw/wjh6FNeRc5OIiIhqKaUugOp34OxlFJU7Z7FHDh4RERGZx7DkovQGgU9+PO+068V14JIARERE5vA2nAtKycxF0meZyC+tcsr1/H080Z+33oiIiMxiWHIxzprQfb3lY3twEjcREVE9eBvOhegNAon/Pua062n9VFg3JYbLAhAREVnAkSUXsu+XSyh38Mrcc+NvRkQbHy4LQEREZCWGJRfyn4zfHfbZoVxckoiIqFEYllzI71fK7fp53p5KvDymB9r6e3MUiYiIqJEYllzITf4+OPxrkd0+77XxvTCyZ1u7fR4REVFzxAneLmRczE12+6yH74hkUCIiIrIDjiy5kAGd28BDCegNjf+MQB8vvDymO0b25NwkIiIie2BYciEeSgWGdQvGVz8VNOr9c+M7I2FwZ85NIiIisiPehnMxU/pH2vwefx9PrJsSgyfjb2ZQIiIisjOOLLmY/h1bw9/H06oNdH28lHhnct//3b5jSCIiInIEjiy5GA+lAsvH9mjwPAWA1++Lxu1dghiUiIiIHIhhyQWN6B6KdVNioPVTmX09VKPG29ymhIiIyCl4G85FjegeiqFRWhzKKUReSQUKyyoR6OsFrYYLTBIRETkTw5IL81AqENextdRlEBERNWu8DUdERERkAcMSERERkQUMS0REREQWMCwRERERWcCwRERERGQBwxIRERGRBQxLRERERBYwLBERERFZwLBEREREZAFX8LYDIQQAoKSkxOJ5Op0O5eXlKCkpgaenpzNKcxp37g1gf3Lnzv25c28A+5MzOfRW+9/t2v+O14dhyQ5KS0sBAGFhYRJXQkRERLYqLS2FRqOp93WFaChOUYMMBgMuXLiAVq1aQaGof4PbkpIShIWF4bfffoOfn58TK3Q8d+4NYH9y5879uXNvAPuTMzn0JoRAaWkp2rZtC6Wy/plJHFmyA6VSiZtuusnq8/38/Fz2B6ep3Lk3gP3JnTv35869AexPzly9N0sjSrU4wZuIiIjIAoYlIiIiIgsYlpxIpVIhKSkJKpVK6lLszp17A9if3Llzf+7cG8D+5MydeuMEbyIiIiILOLJEREREZAHDEhEREZEFDEtEREREFjAsEREREVnAsNQEhYWFmDx5Mvz8/ODv74+ZM2eirKzM4nsqKirw2GOPoXXr1mjZsiXGjRuH/Px84+vHjh3DpEmTEBYWBm9vb3Tr1g2rVq0y+Yw9e/ZAoVDU+ScvL0/2vdX2FxMTA5VKhU6dOmHDhg1266uWI/oDgCeeeAJ9+vSBSqVCdHR0nc84d+6c2T+7AwcO2LM9yfoDgOPHj+P222+HWq1GWFgYXnnlFXu1ZeSo/s6fP4+7774bPj4+CA4Oxrx581BdXW183RG/e2vXrkVERATUajX69euHQ4cOWTx/69at6Nq1K9RqNXr06IHk5GST14UQeOGFFxAaGgpvb2/Ex8fjl19+MTmnMd+/xpKiv4iIiDp/RsuXL7d7b4D9+9u+fTuGDRuG1q1bQ6FQ4OjRo3U+w5qfZXuRor8777yzzp/fI488Ys+2bCeo0UaMGCF69eolDhw4IL7//nvRqVMnMWnSJIvveeSRR0RYWJhIS0sThw8fFv379xcDBgwwvv7BBx+IJ554QuzZs0ecOXNGfPzxx8Lb21usXr3aeM7u3bsFAHHq1CmRm5tr/Eev18u+t7NnzwofHx+RmJgosrKyxOrVq4WHh4dISUmxW2+O6k8IIR5//HGxZs0aMXXqVNGrV686n5GTkyMAiF27dpn82VVVVdmzPcn6Ky4uFiEhIWLy5MkiMzNT/Otf/xLe3t7inXfesWd7DumvurpadO/eXcTHx4uMjAyRnJws2rRpIxYsWGA8x96/e1u2bBFeXl5i/fr14qeffhKzZs0S/v7+Ij8/3+z5e/fuFR4eHuKVV14RWVlZYuHChcLT01OcOHHCeM7y5cuFRqMRO3bsEMeOHROjRo0SkZGR4tq1a036/smpv/DwcPHiiy+a/BmVlZXJor+NGzeKJUuWiPfee08AEBkZGXU+x5rfVTn3N2jQIDFr1iyTP7/i4mK792cLhqVGysrKEgDEjz/+aDz21VdfCYVCIf744w+z7ykqKhKenp5i69atxmPZ2dkCgNi/f3+913r00UfFXXfdZfy69i/sK1euNL0RM6Ts7dlnnxW33HKLyTkTJkwQw4cPb2w7dTijv6SkJIthydxfEPYiZX9vvfWWCAgIEJWVlcZjzz33nOjSpUsTOjLlqP6Sk5OFUqkUeXl5xnPefvtt4efnZ+zH3r97sbGx4rHHHjN+rdfrRdu2bcWyZcvMnn/fffeJu+++2+RYv379xMMPPyyEEMJgMAitViteffVV4+tFRUVCpVKJf/3rX0KIxn3/GkuK/oSoCUsrV660Yyfm2bu/69X3d0Vj/65tDCn6E6ImLD355JNNqt3eeBuukfbv3w9/f3/07dvXeCw+Ph5KpRIHDx40+54jR45Ap9MhPj7eeKxr165o37499u/fX++1iouLERgYWOd4dHQ0QkNDMXToUOzdu7cJ3ZiSsrf9+/ebfAYADB8+3OJn2MqZ/dVn1KhRCA4Oxm233YbPP//c9iYskLK//fv344477oCXl5fx2PDhw3Hq1ClcuXKlEd2Yv4Yj+tu/fz969OiBkJAQk9pLSkrw008/mXyePX73qqqqcOTIEZOalEol4uPj6/2eN/T7kZOTg7y8PJNzNBoN+vXrZ9Knrd8/OfVXa/ny5WjdujV69+6NV1991eR2qj04oj9r2PvvovpI1V+tf/7zn2jTpg26d++OBQsWoLy83ObPsCdupNtIeXl5CA4ONjnWokULBAYG1jt/IS8vD15eXvD39zc5HhISUu979u3bh08++QQ7d+40HgsNDcW6devQt29fVFZW4v3338edd96JgwcPIiYmpmmNQdre8vLyTP5jVfsZJSUluHbtGry9vRvRUd1andGfOS1btsRrr72GgQMHQqlU4j//+Q/GjBmDHTt2YNSoUTb3Ul+tUvWXl5eHyMjIOp9R+1pAQIDVn2XpGo7or76fvdrXAPv+7l26dAl6vd7sNU+ePFlvH+bOv76H6+uu7xxbv3+NIVV/QM3cupiYGAQGBmLfvn1YsGABcnNz8frrrze5r1qO6M8a9vpdbYhU/QHA/fffj/DwcLRt2xbHjx/Hc889h1OnTmH79u22NWFHDEs3mD9/PlasWGHxnOzsbKfUkpmZidGjRyMpKQnDhg0zHu/SpQu6dOli/HrAgAE4c+YMVq5ciY8//rjez5NDb03hSv3Vp02bNkhMTDR+feutt+LChQt49dVXGwxLcuivKeTQX2N/98i5rv8d69mzJ7y8vPDwww9j2bJlbrH1hrubPXu28X/36NEDoaGhGDJkCM6cOYOOHTtKUhPD0g2efvppTJ8+3eI5HTp0gFarRUFBgcnx6upqFBYWQqvVmn2fVqtFVVUVioqKTP5fQX5+fp33ZGVlYciQIZg9ezYWLlzYYN2xsbH44YcfLJ4jh960Wm2dpzry8/Ph5+fX4KiSq/Rnq379+iE1NbXB8+TQX31/frWvWSJ1f1qtts6TPtbUbs3vnjlt2rSBh4eH2e+XpT4snV/77/z8fISGhpqcU/v0YmO+f40hVX/m9OvXD9XV1Th37pxJ2G0KR/RnDUf+XXQ9qfozp1+/fgCA06dPSxaWOMG7kWonSR4+fNh47Ouvv7Zqkum2bduMx06ePFlnYl5mZqYIDg4W8+bNs7qe+Ph4ce+99zaik7qk7O3ZZ58V3bt3Nzk2adIkh0zwdkR/teqbAG3OQw89JHr37m1bExZI2V/tBO/rn+5bsGCBQyZ427u/2gne1z/p88477wg/Pz9RUVFRbz1N+d2LjY0VCQkJxq/1er1o166dxQm0//d//2dyLC4urs4E6H/84x/G14uLi81O8Lbl+9dYUvRnzqZNm4RSqRSFhYVNaacOe/d3vYYmeFv7u9oUUvRnzg8//CAAiGPHjtnWgB0xLDXBiBEjRO/evcXBgwfFDz/8IDp37mzy+O3vv/8uunTpIg4ePGg89sgjj4j27duLb7/9Vhw+fFjExcWJuLg44+snTpwQQUFBYsqUKSaPTRYUFBjPWblypdixY4f45ZdfxIkTJ8STTz4plEql2LVrl+x7q106YN68eSI7O1usXbvWYUsH2Ls/IYT45ZdfREZGhnj44YfFzTffLDIyMkRGRobxaaoNGzaIzZs3i+zsbJGdnS2WLl0qlEqlWL9+vVv0V1RUJEJCQsTUqVNFZmam2LJli/Dx8XHI0gH27q926YBhw4aJo0ePipSUFBEUFGSydIC9f/e2bNkiVCqV2LBhg8jKyhKzZ88W/v7+xifypk6dKubPn288f+/evaJFixbiH//4h8jOzhZJSUlmH6339/cXn332mTh+/LgYPXq02aUDLH3/7EWK/vbt2ydWrlwpjh49Ks6cOSM2bdokgoKCxAMPPCCL/i5fviwyMjLEzp07BQCxZcsWkZGRIXJzc43nWPO7Ktf+Tp8+LV588UVx+PBhkZOTIz777DPRoUMHcccdd9i9P1swLDXB5cuXxaRJk0TLli2Fn5+fmDFjhigtLTW+Xpucd+/ebTx27do18eijj4qAgADh4+Mj7r33XpNfgqSkJAGgzj/h4eHGc1asWCE6duwo1Gq1CAwMFHfeeaf49ttv3aI3IWoez46OjhZeXl6iQ4cO4sMPP7Rrb47qT4iaR17N9ZiTkyOEqAlL3bp1Ez4+PsLPz0/ExsaaPAIs9/6EEOLYsWPitttuEyqVSrRr104sX75cNv2dO3dO/OUvfxHe3t6iTZs24umnnxY6nc74uiN+91avXi3at28vvLy8RGxsrDhw4IDxtUGDBolp06aZnP/vf/9b3HzzzcLLy0vccsstYufOnSavGwwGsWjRIhESEiJUKpUYMmSIOHXqlMk5DX3/7MnZ/R05ckT069dPaDQaoVarRbdu3cTf//53i6ODrtTfhx9+aPZ3LCkpyXiONT/Lcu3v/Pnz4o477hCBgYFCpVKJTp06iXnz5km+zpJCCCHse2OPiIiIyH1wnSUiIiIiCxiWiIiIiCxgWCIiIiKygGGJiIiIyAKGJSIiIiILGJaIiIiILGBYIiIiIrKAYYmIiIjIAoYlIiIiIgsYlojI6S5evIg5c+agffv2UKlU0Gq1GD58OPbu3WvX60yfPh1jxoyx6jyFQgGFQgFPT09ERkbi2WefRUVFhdXX2rNnDxQKBYqKihpfMBG5pBZSF0BEzc+4ceNQVVWFjz76CB06dEB+fj7S0tJw+fJlyWoaMWIEPvzwQ+h0Ohw5cgTTpk2DQqHAihUrnF6LTqeDp6en069LROZxZImInKqoqAjff/89VqxYgbvuugvh4eGIjY3FggULMGrUKON5CoUCb7/9Nv7yl7/A29sbHTp0wLZt20w+68SJExg8eDC8vb3RunVrzJ49G2VlZQCAxYsX46OPPsJnn31mHDXas2dPvXXVjnCFhYVhzJgxiI+PR2pqqvF1g8GAZcuWITIyEt7e3ujVq5exnnPnzuGuu+4CAAQEBEChUGD69OkAgIiICLzxxhsm14qOjsbixYvr9Dpq1Cj4+vpi6dKlWLx4MaKjo/Hxxx8jIiICGo0GEydORGlpqfF927ZtQ48ePYz9x8fH4+rVq1b/WRCRdRiWiMipWrZsiZYtW2LHjh2orKy0eO6iRYswbtw4HDt2DJMnT8bEiRORnZ0NALh69SqGDx+OgIAA/Pjjj9i6dSt27dqFhIQEAMAzzzyD++67DyNGjEBubi5yc3MxYMAAq2rMzMzEvn374OXlZTy2bNkybNy4EevWrcNPP/2EuXPnYsqUKfjuu+8QFhaG//znPwCAU6dOITc3F6tWrbLp+7J48WLce++9OHHiBB588EEAwJkzZ7Bjxw58+eWX+PLLL/Hdd99h+fLlAIDc3FxMmjQJDz74ILKzs7Fnzx6MHTsW3BudyAEEEZGTbdu2TQQEBAi1Wi0GDBggFixYII4dO2ZyDgDxyCOPmBzr16+fmDNnjhBCiHfffVcEBASIsrIy4+s7d+4USqVS5OXlCSGEmDZtmhg9enSD9UybNk14eHgIX19foVKpBAChVCrFtm3bhBBCVFRUCB8fH7Fv3z6T982cOVNMmjRJCCHE7t27BQBx5coVk3PCw8PFypUrTY716tVLJCUlmfT61FNPmZyTlJQkfHx8RElJifHYvHnzRL9+/YQQQhw5ckQAEOfOnWuwPyJqGo4sEZHTjRs3DhcuXMDnn3+OESNGYM+ePYiJicGGDRtMzouLi6vzde3IUnZ2Nnr16gVfX1/j6wMHDoTBYMCpU6dsrumuu+7C0aNHcfDgQUybNg0zZszAuHHjAACnT59GeXk5hg4dahwZa9myJTZu3IgzZ87YfC1z+vbtW+dYREQEWrVqZfw6NDQUBQUFAIBevXphyJAh6NGjB8aPH4/33nsPV65csUstRGSKYYmIJKFWqzF06FAsWrQI+/btw/Tp05GUlCRZPb6+vujUqRN69eqF9evX4+DBg/jggw8AwDgPaufOnTh69Kjxn6ysrDrzqG6kVCrr3BrT6XRmr3+jGyd5KxQKGAwGAICHhwdSU1Px1VdfISoqCqtXr0aXLl2Qk5NjfdNEZBWGJSJyCVFRUXUmJx84cKDO1926dQMAdOvWDceOHTN5z969e6FUKtGlSxcAgJeXF/R6vc21KJVKPP/881i4cCGuXbuGqKgoqFQqnD9/Hp06dTL5JywszHgtAHWuFxQUhNzcXOPXJSUldgs0CoUCAwcOxJIlS5CRkQEvLy98+umndvlsIvoTwxIROdXly5cxePBgbNq0CcePH0dOTg62bt2KV155BaNHjzY5d+vWrVi/fj1+/vlnJCUl4dChQ8YJ3JMnT4Zarca0adOQmZmJ3bt34/HHH8fUqVMREhICoOY21vHjx3Hq1ClcunTJ7IhOfcaPHw8PDw+sXbsWrVq1wjPPPIO5c+fio48+wpkzZ5Ceno7Vq1fjo48+AgCEh4dDoVDgyy+/xMWLF42jUYMHD8bHH3+M77//HidOnMC0adPg4eHR5O/jwYMH8fe//x2HDx/G+fPnsX37dly8eNEYJonIjqSeNEVEzUtFRYWYP3++iImJERqNRvj4+IguXbqIhQsXivLycuN5AMTatWvF0KFDhUqlEhEREeKTTz4x+azjx4+Lu+66S6jVahEYGChmzZolSktLja8XFBSIoUOHipYtWwoAYvfu3WZrqm8i+LJly0RQUJAoKysTBoNBvPHGG6JLly7C09NTBAUFieHDh4vvvvvOeP6LL74otFqtUCgUYtq0aUIIIYqLi8WECROEn5+fCAsLExs2bDA7wfvTTz81uXZSUpLo1auXybGVK1eK8PBwIYQQWVlZYvjw4SIoKEioVCpx8803i9WrV5v/phNRkyiE4HOmROR6FAoFPv30U6tW4CYiciTehiMiIiKygGGJiIiIyALuDUdELokzBIjIVXBkiYiIiMgChiUiIiIiCxiWiIiIiCxgWCIiIiKygGGJiIiIyAKGJSIiIiILGJaIiIiILGBYIiIiIrLg/wGCXSwSGXF99wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pyplot.scatter(spot_returns, futures_returns)\n",
    "pyplot.xlabel('Spot Returns')\n",
    "pyplot.ylabel('Futures Returns')\n",
    "pyplot.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7ed03b55-63b3-43f5-98f9-e85ae9004e0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            OLS Regression Results                            \n",
      "==============================================================================\n",
      "Dep. Variable:                      y   R-squared:                       0.997\n",
      "Model:                            OLS   Adj. R-squared:                  0.997\n",
      "Method:                 Least Squares   F-statistic:                 1.517e+10\n",
      "Date:                Wed, 19 Feb 2025   Prob (F-statistic):               0.00\n",
      "Time:                        07:51:32   Log-Likelihood:             4.2702e+08\n",
      "No. Observations:            52429255   AIC:                        -8.540e+08\n",
      "Df Residuals:                52429253   BIC:                        -8.540e+08\n",
      "Df Model:                           1                                         \n",
      "Covariance Type:            nonrobust                                         \n",
      "==============================================================================\n",
      "                 coef    std err          t      P>|t|      [0.025      0.975]\n",
      "------------------------------------------------------------------------------\n",
      "const      -1.073e-07    9.7e-09    -11.064      0.000   -1.26e-07   -8.83e-08\n",
      "x1             1.0108   8.21e-06   1.23e+05      0.000       1.011       1.011\n",
      "==============================================================================\n",
      "Omnibus:                 15081138.655   Durbin-Watson:                   0.073\n",
      "Prob(Omnibus):                  0.000   Jarque-Bera (JB):       1379496851.216\n",
      "Skew:                           0.380   Prob(JB):                         0.00\n",
      "Kurtosis:                      28.118   Cond. No.                         846.\n",
      "==============================================================================\n",
      "\n",
      "Notes:\n",
      "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
     ]
    }
   ],
   "source": [
    "X = sm.add_constant(spot_returns)\n",
    "\n",
    "model = sm.OLS(futures_returns, X).fit()\n",
    "\n",
    "print(model.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bacd7d3f-842d-4188-8879-1677ff59e897",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1h 5min 3s, sys: 1min 56s, total: 1h 7min\n",
      "Wall time: 42min 43s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "roi_lb = 10000\n",
    "roi_ub = 90000\n",
    "\n",
    "data = []\n",
    "date = start_date\n",
    "while date <= end_date:\n",
    "    data.append('data2/btcusdt_{}.npz'.format(date.strftime(\"%Y%m%d\")))\n",
    "    date += datetime.timedelta(days=1)\n",
    "\n",
    "asset = (\n",
    "    BacktestAsset()\n",
    "        .data(data)\n",
    "        .initial_snapshot('data2/btcusdt_20240831_eod.npz')\n",
    "        .linear_asset(1.0) \n",
    "        .constant_latency(10_000_000, 10_000_000)\n",
    "        .power_prob_queue_model(3)\n",
    "        .no_partial_fill_exchange()\n",
    "        .trading_value_fee_model(-0.00005, 0.0007)\n",
    "        .tick_size(0.1)\n",
    "        .lot_size(0.001)\n",
    "        .roi_lb(roi_lb)    \n",
    "        .roi_ub(roi_ub)\n",
    ")\n",
    "\n",
    "hbt = ROIVectorMarketDepthBacktest([asset])\n",
    "\n",
    "recorder = Recorder(1, 60_000_000)\n",
    "\n",
    "half_spread = 0.0003 # a ratio relative to the fair price\n",
    "skew = half_spread / 20\n",
    "interval = 100_000_000 # in nanoseconds. 100ms\n",
    "order_qty_dollar = 50_000\n",
    "max_position_dollar = order_qty_dollar * 20\n",
    "grid_num = 1\n",
    "grid_interval = hbt.depth(0).tick_size\n",
    "\n",
    "apt_mm(\n",
    "    hbt,\n",
    "    recorder.recorder,\n",
    "    half_spread,\n",
    "    skew,\n",
    "    precompute_data,\n",
    "    interval,\n",
    "    order_qty_dollar,\n",
    "    max_position_dollar,\n",
    "    grid_num,\n",
    "    grid_interval,\n",
    "    roi_lb,\n",
    "    roi_ub\n",
    ")\n",
    "\n",
    "hbt.close()\n",
    "\n",
    "recorder.to_npz('stats/underlying_btcfdusd_return_5m.npz')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fbdd458d-6b9f-4629-94f3-7deb27771a73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div><style>\n",
       ".dataframe > thead > tr,\n",
       ".dataframe > tbody > tr {\n",
       "  text-align: right;\n",
       "  white-space: pre-wrap;\n",
       "}\n",
       "</style>\n",
       "<small>shape: (1, 11)</small><table border=\"1\" class=\"dataframe\"><thead><tr><th>start</th><th>end</th><th>SR</th><th>Sortino</th><th>Return</th><th>MaxDrawdown</th><th>DailyNumberOfTrades</th><th>DailyTurnover</th><th>ReturnOverMDD</th><th>ReturnOverTrade</th><th>MaxPositionValue</th></tr><tr><td>datetime[μs]</td><td>datetime[μs]</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td><td>f64</td></tr></thead><tbody><tr><td>2024-09-01&nbsp;00:00:00</td><td>2024-10-31&nbsp;23:55:00</td><td>6.061161</td><td>8.0366</td><td>0.060375</td><td>0.013698</td><td>436.467467</td><td>8.72937</td><td>4.407667</td><td>0.000113</td><td>1.0583e6</td></tr></tbody></table></div>"
      ],
      "text/plain": [
       "shape: (1, 11)\n",
       "┌────────────┬────────────┬──────────┬─────────┬───┬───────────┬───────────┬───────────┬───────────┐\n",
       "│ start      ┆ end        ┆ SR       ┆ Sortino ┆ … ┆ DailyTurn ┆ ReturnOve ┆ ReturnOve ┆ MaxPositi │\n",
       "│ ---        ┆ ---        ┆ ---      ┆ ---     ┆   ┆ over      ┆ rMDD      ┆ rTrade    ┆ onValue   │\n",
       "│ datetime[μ ┆ datetime[μ ┆ f64      ┆ f64     ┆   ┆ ---       ┆ ---       ┆ ---       ┆ ---       │\n",
       "│ s]         ┆ s]         ┆          ┆         ┆   ┆ f64       ┆ f64       ┆ f64       ┆ f64       │\n",
       "╞════════════╪════════════╪══════════╪═════════╪═══╪═══════════╪═══════════╪═══════════╪═══════════╡\n",
       "│ 2024-09-01 ┆ 2024-10-31 ┆ 6.061161 ┆ 8.0366  ┆ … ┆ 8.72937   ┆ 4.407667  ┆ 0.000113  ┆ 1.0583e6  │\n",
       "│ 00:00:00   ┆ 23:55:00   ┆          ┆         ┆   ┆           ┆           ┆           ┆           │\n",
       "└────────────┴────────────┴──────────┴─────────┴───┴───────────┴───────────┴───────────┴───────────┘"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.load('stats/underlying_btcfdusd_return_5m.npz')['0']\n",
    "stats = (\n",
    "    LinearAssetRecord(data)\n",
    "        .resample('5m')\n",
    "        .stats(book_size=2_500_000)\n",
    ")\n",
    "stats.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ed5b2933-b246-4e70-8af8-693a2a6ec803",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "stats.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2cf5729-8911-4c25-bc66-abea0cf5b467",
   "metadata": {},
   "source": [
    "An example using multiple linear regression based on multiple factors will be added."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
